package ArrayHomeWork;

import java.util.Arrays;

public class Test {
    public static void main(String[] args) {
//        //14实现一个方法 copyOf, 对一个整型数组进行拷贝, 得到一个新的数组.
        int[] arr={1,2,3,4,5,8,9};
        System.out.println(Arrays.toString(arr));
        int[] ret=arrCopy(arr);
        System.out.println(Arrays.toString(ret));

//        int[] arr={1,2,3,4,5,8,9};
//        String s=toString(arr);
//        System.out.println(s);


        //12.给定一个有序整型数组, 实现二分查找
//        int[] arr={1,2,3,4,5,8,9};
//        int target=8;
//        int num=binarySearchFactor(arr,0,arr.length-1,target);
//        System.out.println(num);
//        System.out.println(binarySearch(arr,0,arr.length-1,18));


        //11.给定一个整型数组, 判定数组是否有序（递增）
//        int[] arr={1,2,3,6,5};
//        boolean bool=isOrder(arr);
//        if(bool==false){
//            System.out.println("无序");
//        }else{
//            System.out.println("有序");
//        }

        //10.给定一个整型数组, 实现冒泡排序(升序排序)
//        int[] arr={5,7,9,6,4};
//        bubble(arr);
//        System.out.println(Arrays.toString(arr));

        //9.给定一个整数数组 nums 和一个整数目标值 target
        // 请你在该数组中找出和为目标值 target 的那 两个 整数，并返回它们的数组下标。
//        假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。你可以按任意顺序返回答案
//        int[] nums={6,4,3,7,5};
//        int target=13;
//        int[]arr=findTarget(nums,target);
//        System.out.println(Arrays.toString(arr));


        //8.给定一个非空整数数组，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素。
//        int[] arr = {3, 5, 4, 3, 2, 4, 2};
//        System.out.println(findElement(arr));

        //7.给定一个大小为 n 的数组，找到其中的多数元素。多数元素是指在数组中出现次数 大于 ⌊ n/2 ⌋ 的元素。
        //你可以假设数组是非空的，并且给定的数组总是存在多数元素。
//        int[] arr={1,2,7,6,87,7,7,7,2,2,2,5,2,2};
//        System.out.println(arrayMostElements3(arr));
////        System.out.println("多数元素为"+arrayMostElements1(arr));
//        bubbleSort(arr);
//        System.out.println(Arrays.toString(arr));
//        //6
//        int[] arr={2,6,2,3,4};
//        int[] arr1={5,6,9,7,5,4};
//        System.out.println(isOddArray(arr));
//        System.out.println(isOddArray(arr1));


        //5.创建一个 int 类型的数组, 元素个数为 100, 并把每个元素依次设置为 1 - 100
//        int[] arr=new int[100];
//        arrayAssign(arr);
//        for (int i = 0; i < arr.length; i++) {
//            System.out.print(arr[i]+" ");
//        }
        //4.模拟实现toString()
//        int[] arr=new int[]{1,4,9,8};
//        System.out.println(arr);
//        System.out.println(arrStr(arr));
        //3.遍历数组。实现一个方法 printArray, 以数组为参数, 循环访问数组中的每个元素, 打印每个元素的值
//        int[] arr=new int[]{1,4,9,8};
//        printArray(arr);
//        System.out.println();
//        printArray1(arr);
       //2.实现一个方法 transform, 以数组为参数, 循环将数组中的每个元素 乘以 2 , 并设置到对应的数组元素上
        // 例如 原数组为 {1, 2, 3}, 修改之后为 {2, 4, 6}
//        int[] arr=new int[]{1,3,4};
//        System.out.println(Arrays.toString(arr));
//        int[] ret=transform1(arr);
//        System.out.println(Arrays.toString(arr));
//        System.out.println(Arrays.toString(ret));
        //1.求和与求平均值【包含递归方法求和】
//        int[] arr=new int[]{1,2,3,5,7};
//        System.out.println(avg(arr));
//        System.out.println(sum(arr,0, arr.length-1));
    }
//14.模拟实现数组拷贝
  public static int[] arrCopy(int[] arr){
        //实现数组全拷贝
        int[] ret=new int[arr.length];
        for (int i = 0; i < arr.length; i++) {
            ret[i]=arr[i];
        }
        return ret;
    }

    //实现一个方法 toString, 把一个整型数组转换成字符串. 例如数组 {1, 2, 3} , 返回的字符串为 "[1, 2, 3]", 注意 逗号 的位置和数量.
//    public static String toString(int[] arr){
//        String s="[";
//        for (int i = 0; i < arr.length; i++) {
//            s+=arr[i];
//            if(i!=arr.length-1){
//                s+=",";
//            }
//        }
//        s+="]";
//        return s;
//    }




//    //12.二分查找
//    public static int binarySearchFactor(int[] arr,int left,int right,int target){
//        if(left>right){
//            return -1;
//        }
//        int mid=(left+right)>>1;
//        if(target<arr[mid]){
//          return  binarySearchFactor(arr,left,mid-1,target);
//        }else if(target>arr[mid]){
//         return   binarySearchFactor(arr,mid+1,right,target);
//        }else{
//            return mid;
//        }
//    }
//
//
//    private static int binarySearch(int[] arr, int left, int right,int target) {
//       while(left<right){
//           int mid=(left+right)>>1;
//           if(target<arr[mid]){
//               right=mid-1;
//           }else if(target>arr[mid]){
//               left=mid+1;
//           }else{
//               return mid;//返回找到的下标
//           }
//       }
//       return -1;
//    }
//11.给定一个整型数组, 判定数组是否有序（递增）
//    private static boolean isOrder(int[] arr) {
//        for (int i = 0; i < arr.length-1; i++) {
//            if(arr[i]>arr[i+1]){
//                return false;
//            }
//        }
//        return true;
//    }



    //10.冒泡排序
//    private static void bubble(int[] arr) {
//        for (int i = 0; i < arr.length-1; i++) {//走的趟数
//            boolean bool=false;
//            for (int j = 0; j < arr.length-i-1 ; j++) {//每趟冒得泡数
//                if(arr[j]>arr[j+1]){
//                    int tmp=arr[j];
//                    arr[j]=arr[j+1];
//                    arr[j+1]=tmp;
//                    bool=true;
//                }
//            }
//            if(bool==false){
//                break;
//            }
//        }
//    }
//
//


    //9.给定一个整数数组 nums 和一个整数目标值 target
    // 请你在该数组中找出和为目标值 target 的那 两个 整数，并返回它们的数组下标。
//        假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。你可以按任意顺序返回答案
//    public static int[] findTarget(int[] nums,int target){
//        int[] arr=new int[2];
//        for (int i = 0; i < nums.length; i++) {//left可能走的次数
//            for (int j = nums.length-1; j >i ; j--) {
//                if(nums[i]+nums[j]==target){
//                    arr[0]=i;
//                    arr[1]=j;
//                }
//            }
//        }
//        return arr;
//    }


    //8.给定一个非空整数数组，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素。
    //异或操作0^n=n;n^n=0
//    public static int findElement(int[] arr){
//        int n=0;
//        for (int i:arr) {
//            n^=i;
//        }
//        return n;
//    }



    //7.给定一个大小为 n 的数组，找到其中的多数元素。多数元素是指在数组中出现次数 大于 ⌊ n/2 ⌋ 的元素。
    //你可以假设数组是非空的，并且给定的数组总是存在多数元素。
//    public static int arrayMostElements3(int[] arr){//投票法
//        int count=0;
//        Integer num=null;//不能定义整数Num=0，万一众数就是0呢
//        for (int i = 0; i < arr.length; i++) {
//            if(count==0){//当count==0时，换候选人【换锁定数字】，把当时位置对应的值赋值给num
//                num=arr[i];
//            }
//            if(arr[i]==num){
//                count++;
//            }else{
//                count--;
//            }
//
//        }
//        return num;
//    }
//
//
//   public static int arrayMostElementsFactor(int[] arr,int left,int right){//分治法【递归实现】
//       if(left==right){//区间只有一个元素
//           return arr[left];
//       }
//       int mid=(right+left)/2;
//       //左半区间众数
//       int leftNum=arrayMostElementsFactor(arr,left,mid);
//       //右半区间众数
//       int rightNum=arrayMostElementsFactor(arr,mid+1,right);
//       if(leftNum==rightNum){
//           return leftNum;
//       }
//       //需要知道左半区间与右半区间种leftNum,rightNum分别出现的次数，返回次数多的,这个数就是众数
//       int leftCount=count(arr,leftNum);//找leftNum在arr种出现的次数
//       int rightCount=count(arr,rightNum);
//       return leftCount>rightCount?leftNum:rightNum;
//   }
//
//    private static int count(int[] arr, int num) {
//        int count=0;
//        for (int i:arr) {
//            if(i==num){
//                count++;
//            }
//        }
//        return count;
//    }
//
//    public static int arrayMostElements2(int[] arr){
//
//      return  arrayMostElementsFactor(arr,0,arr.length-1);
//    }
//
//
//
//    public static int arrayMostElements1(int[] arr){
//        //排序法
//       bubbleSort(arr);
//       return arr[arr.length/2];
//    }
//
//    private static void bubbleSort(int[] arr) {
//
//        for (int i = 0; i < arr.length-1; i++) {//走的趟数
//            boolean b=false;
//            for (int j = 0; j < arr.length-i-1; j++) {//交换的次数
//                if(arr[j]>arr[j+1]){
//                    int tmp=arr[j];
//                    arr[j]=arr[j+1];
//                    arr[j+1]=tmp;
//                    b=true;
//                }
//            }
//            if(b==false){
//                break;
//            }
//        }
//
//    }


//    给你一个整数数组 arr，请你判断数组中是否存在连续三个元素都是奇数的情况：如果存在，请返回 true ；否则，返回 false 。
//    示例 1：
//    输入：arr = [2,6,4,1]
//    输出：false
//    解释：不存在连续三个元素都是奇数的情况。
//    示例 2：
//    输入：arr = [1,2,34,3,4,5,7,23,12]
//    输出：true
//    解释：存在连续三个元素都是奇数的情况，即 [5,7,23] 。
//    public static boolean isOddArray(int[] arr){
//        int count=0;
//        for (int i :arr) {
//            if(i%2!=0) {
//                count++;
//            }else {
//                count=0;
//            }
//            if(count==3){
//                return true;
//            }
//        }
//        return false;
//    }

    //5.创建一个 int 类型的数组, 元素个数为 100, 并把每个元素依次设置为 1 - 100
//    public static void arrayAssign(int[] arr){
//        for (int i = 0; i < arr.length; i++) {
//            arr[i]=i+1;
//        }
//    }
    //4.模拟实现toString()
//    public static String arrStr(int[] arr){
//       String ret="[";
//        for (int i = 0; i < arr.length; i++) {
//            ret+=arr[i];
//            if (i!= arr.length-1) {
//                ret += ",";
//            }
//        }
//        ret+="]";
//        return ret;
//    }


    //3.遍历数组：实现一个方法 printArray, 以数组为参数, 循环访问数组中的每个元素, 打印每个元素的值
//    public static void printArray(int[] arr){
//        for (int i = 0; i < arr.length; i++) {
//            System.out.print(arr[i]+" ");
//        }
//    }
//    public static void printArray1(int[] arr){
//        for (int i :arr) {
//            System.out.print(i+" ");
//        }
//    }




    //2.实现一个方法 transform, 以数组为参数, 循环将数组中的每个元素 乘以 2 , 并设置到对应的数组元素上
    // 例如 原数组为 {1, 2, 3}, 修改之后为 {2, 4, 6}
//    public static void transform(int[] arr){
//        //将原数组值改变扩大2倍
//        for (int i = 0; i < arr.length; i++) {
//            arr[i]=2*arr[i];
//        }
//    }
//    public static int[] transform1(int[] arr){
//        //不改变原数组值
//        int[] ret=new int[arr.length];
//        for (int i = 0; i < ret.length; i++) {
//            ret[i]=arr[i]*2;
//        }
//        return ret;
//    }


    //求和与求平均值【包含递归方法求和】
//    //递归方法实现求和
//    public static int sum(int[] arr,int left,int right){
//        //数组是天然递归结构
//        if(right<left){
//            return -1;//空区间
//        }
//        if(left==right){
//            return arr[right];
//        }
//        return arr[right]+sum(arr,left,right-1);
//    }
//    //实现一个方法 avg, 以数组为参数, 求数组中所有元素的平均值(注意方法的返回值类型)//先求和，再计算平均值
//    public static double avg(int[] arr){
//        double num=sum(arr,0,arr.length-1)/(double)arr.length;
//        return num;
//    }
//    public static int sum(int[] arr){//求和
//        int add=0;
//        for (int i = 0; i < arr.length; i++) {
//            add+=arr[i];
//
//        }
//        return add;
//    }
}